package xyz.heyaoshare.utils;

import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.List;

/**
 * JSON工具类【基于hu-tool】
 * @author YueHe
 * @version 0.0.1
 * @since 2025/6/25 上午10:46
 */
public class JSONUtils extends JSONUtil {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, Boolean.FALSE);
    }

    /**
     * 将对象转换为 JSON 字符串【基于objectMapper】
     *
     * @param object 要转换的对象
     * @return 转换后的 JSON 字符串
     * @throws RuntimeException 如果转换过程中出现错误，抛出运行时异常
     */
    public static String toJsonString(Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将给定的文本解析为指定类型的对象【基于objectMapper】
     *
     * @param text 要解析的文本
     * @param clazz 要解析成的目标类的 Class 对象
     * @param <T> 目标类的类型参数
     * @return 解析后的对象，如果文本为空则返回 null
     * @throws RuntimeException 如果解析过程中出现异常，则抛出运行时异常
     */
    public static <T> T parseObject(String text, Class<T> clazz) {
        if (StrUtil.isEmpty(text)) {
            return null;
        }
        try {
            return objectMapper.readValue(text, clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将字节数组解析为指定类型的对象【基于objectMapper】
     *
     * @param bytes 字节数组，表示需要解析的数据
     * @param clazz 目标对象的类类型
     * @param <T>   目标对象的类型
     * @return 解析后的对象，如果字节数组为空则返回null
     * @throws RuntimeException 如果解析过程中出现异常，则抛出运行时异常
     */
    public static <T> T parseObject(byte[] bytes, Class<T> clazz) {
        if (ArrayUtil.isEmpty(bytes)) {
            return null;
        }
        try {
            return objectMapper.readValue(bytes, clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将字符串解析为指定类型的对象【基于objectMapper】
     *
     * @param text 待解析的字符串
     * @param typeReference 目标类型的引用
     * @param <T> 目标类型
     * @return 解析后的对象
     * @throws RuntimeException 如果解析失败，抛出运行时异常
     */
    public static <T> T parseObject(String text, TypeReference<T> typeReference) {
        try {
            return objectMapper.readValue(text, typeReference);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 将字符串解析为指定类型的列表【基于objectMapper】
     *
     * @param text 待解析的字符串
     * @param clazz 目标类型的Class对象
     * @param <T> 列表元素类型
     * @return 解析后的列表
     * @throws RuntimeException 如果解析过程中出现异常，抛出运行时异常
     */
    public static <T> List<T> parseArray(String text, Class<T> clazz) {
        if (StrUtil.isEmpty(text)) {
            return new ArrayList<>();
        }
        try {
            return objectMapper.readValue(text, objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}
